﻿using System;
using System.Collections;
using System.Xml;
using Narau.Required_interfaces;

namespace Narau.Common
{
    class Mondai
    {        
        private XmlNode      m_xml_node;
        //private string       m_strDesc;
        private ArrayList    m_tema_list;
        private ArrayList    m_solution_list;
        private MondaiResult m_result;
        private int          m_UID = 0;

        public MondaiResult Result { get { return m_result; } set { m_result = value; } }
        public int UID
        {
            get { return m_UID; }
            set 
            {
                if (m_xml_node != null)
                {
                    XmlAttribute xml_attr = m_xml_node.Attributes["uid"];
                    if (xml_attr != null)
                    {
                        xml_attr.Value = Convert.ToString(value);
                    }
                }
                m_UID=value;
            }
        }
            
        //--------------
        // Constructor
        //--------------
        public Mondai()
        {
            m_solution_list = new ArrayList();
            m_tema_list = new ArrayList();
        }

        //--------------------
        // XMLから問題を作る
        //--------------------
        public void XmlKaraTsukuru(XmlNode mondai_desc_xml)
        {
            m_xml_node = mondai_desc_xml;

            // Creación del atributo de UID, si no existe
            CheckCreateAttribute(m_xml_node, "uid", ref m_UID);

            // <desc>
            //[H][B]
            /*XmlNode xml_node_desc = m_xml_node.SelectSingleNode("desc");
            XmlAttribute xml_attr_str = xml_node_desc.Attributes["str"];
            if(xml_attr_str != null)
            {
                m_strDesc = xml_attr_str.Value;
            }
            else
            {
                m_strDesc = "";
            }*/
        }

        //----------------------------------------------------------------------------
        // Comprueba si existe el atributo dado en el nodo. Lo crea si no existe y
        // establece el valor del atributo en la variable pasada por referencia
        //----------------------------------------------------------------------------
        private void CheckCreateAttribute(XmlNode xml_node, string nAttr, ref int iValue)
        {
            XmlAttribute xml_attr = xml_node.Attributes[nAttr];
            if (xml_attr == null)
            {
                xml_attr = xml_node.OwnerDocument.CreateAttribute(nAttr);
                xml_attr.Value = "0";
                xml_node.Attributes.Append(xml_attr);
                iValue = 0;
            }
            else
            {
                iValue = Convert.ToInt32(xml_attr.Value);
            }
        }

        //----------------------------------------------------------------------------
        // Muestra el ejercicio en la vista a través del required interface genérico
        //----------------------------------------------------------------------------
        public void Suru(ReqIntf_Label i_Label_desc, ReqIntf_Panel i_Panel)
        {
            if (m_xml_node != null)
            {
                XmlNode xml_node_desc = m_xml_node.SelectSingleNode("desc");
                if(xml_node_desc != null)
                {
                    ParseDescNode(xml_node_desc, i_Label_desc);
                    //[H][B]
                    /*XmlAttribute xml_attr_str = xml_node_desc.Attributes["str"];
                    if(xml_attr_str != null)
                    {
                        i_Label_desc.SetText(xml_attr_str.Value);
                    }*/
                }

                XmlNode xml_node_data = m_xml_node.SelectSingleNode("data");
                if (xml_node_data != null)
                {
                    ParseDataNode(xml_node_data, i_Panel);
                }
            }
        }

        //-------------------------------------------------------------
        // Parsea el nodo <desc> del XML donde se define el ejercicio
        // y lo representa a través del interfaz 'ReqIntf_Label' 
        //-------------------------------------------------------------
        private void ParseDescNode(XmlNode xml_node_desc, ReqIntf_Label i_Label_desc)
        {
            string strEnunciado = "";

            foreach (XmlNode xml_data in xml_node_desc.ChildNodes)
            {
                if (xml_data.Name.Equals("txt"))
                {
                    XmlAttribute xml_attr_str = xml_data.Attributes["str"];
                    if (xml_attr_str != null)
                    {
                        strEnunciado += xml_attr_str.Value + "\n\n";
                    }
                }
            }

            i_Label_desc.SetText(strEnunciado);
        }

        //-------------------------------------------------------------
        // Parsea el nodo <data> del XML donde se define el ejercicio
        // y lo representa a través del interfaz 'ReqIntf_Panel'
        //-------------------------------------------------------------
        private void ParseDataNode(XmlNode xml_node_data, ReqIntf_Panel i_Panel)
        {
            foreach (XmlNode xml_data in xml_node_data.ChildNodes)
            {
                if (xml_data.Name.Equals("txt"))
                {
                    XmlAttribute xml_attr_str = xml_data.Attributes["str"];
                    if (xml_attr_str != null)
                    {
                        i_Panel.AddText(xml_attr_str.Value, ENR_FontType.NFT_NIHONGO, false);
                    }
                }
                else
                {
                    if (xml_data.Name.Equals("sol"))
                    {
                        XmlAttribute xml_attr_str = xml_data.Attributes["str"];
                        if (xml_attr_str != null)
                        {
                            ReqIntf_InputBox reqIntf = i_Panel.AddInputBox(xml_attr_str.Value.Length);
                            Solution newSol = new Solution(xml_attr_str.Value, reqIntf);

                            m_solution_list.Add(newSol);
                        }
                    }
                }
            }
        }

        //---------------------------------------------
        // ¿El ejercicio está correctamente resuelto?
        //---------------------------------------------
        public bool IsOK()
        {
            return m_result.IsOk();
        }

        //--------------------------------------------------------------------------------
        // Comprueba que el usuario haya introducido las respuestas correctas para todas
        // las soluciones del ejercicio
        //--------------------------------------------------------------------------------
        public void Check(int iTick)
        {
            //bool bOK = (m_solution_list.Count != 0);

            bool bOK = true;
            foreach (Solution itSol in m_solution_list)
            {
                bool bCurrentOK = itSol.IsOk();
                bOK = bOK && bCurrentOK;
            }

            m_result.SetMaru(iTick, bOK);
        }

        //----------------------------------------------
        // Enlace con los temas que trata el ejercicio
        //----------------------------------------------
        public void LinkTemas(ArrayList tema_list)
        {
            XmlNode xml_node_temas = m_xml_node.SelectSingleNode("temas");
            foreach (XmlNode xml_tema in xml_node_temas)
            {
                XmlAttribute xml_attr_uid = xml_tema.Attributes["uid"];
                if (xml_attr_uid != null)
                {
                    foreach (Tema itTema in tema_list)
                    {
                        if (itTema.StrUID == xml_attr_uid.Value)
                        {
                            itTema.AddMondai(this);
                            m_tema_list.Add(itTema);
                        }
                    }
                }
            }            
        }
    }
}
